package com.garlicts.framework.ioc;

import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;

import com.garlicts.framework.core.InstanceFactory;
import com.garlicts.framework.core.BeanLoader;
import com.garlicts.framework.core.fault.InitializationError;
import com.garlicts.framework.annotation.Autowired;
import com.garlicts.framework.util.ArrayUtil;
import com.garlicts.framework.util.CollectionUtil;

/**
 * 初始化 IOC 容器
 *
 * @author 水木星辰
 * @since 1.0
 */
public class IocComponent implements IocInit {

	BeanLoader beanLoader = InstanceFactory.getBeanLoader();

	static {

	}

	// /**
	// * 查找实现类
	// */
	// public static Class<?> findImplementClass(Class<?> interfaceClass) {
	// Class<?> implementClass = interfaceClass;
	// // 判断接口上是否标注了 Impl 注解
	// if (interfaceClass.isAnnotationPresent(Impl.class)) {
	// // 获取强制指定的实现类
	// implementClass = interfaceClass.getAnnotation(Impl.class).cron();
	// } else {
	// // 获取该接口所有的实现类
	// List<Class<?>> implementClassList =
	// AnnotationBeanFactory.getBeanListBySuper(interfaceClass);
	// if (CollectionUtil.isNotEmpty(implementClassList)) {
	// // 获取第一个实现类
	// implementClass = implementClassList.get(0);
	// }
	// }
	// // 返回实现类对象
	// return implementClass;
	// }

	/**
	 * 查找实现类
	 */
	public Class<?> findImplementClass(Class<?> interfaceClass) {

		Class<?> implementClass = interfaceClass;
		// 获取该接口所有的实现类
		List<Class<?>> implementClassList = beanLoader.getBeanClassListBySuper(interfaceClass);
		if (CollectionUtil.isNotEmpty(implementClassList)) {
			// 获取第一个实现类
			implementClass = implementClassList.get(0);
		}
		// 返回实现类对象
		return implementClass;
	}

	@Override
	public void init() {

		try {

			// 获取并遍历所有的 Bean 类
			Map<Class<?>, Object> beanMap = BeanContainerComponent.getBeanMap();
			for (Map.Entry<Class<?>, Object> beanEntry : beanMap.entrySet()) {
				// 获取 Bean 类与 Bean 实例
				Class<?> beanClass = beanEntry.getKey();
				Object beanInstance = beanEntry.getValue();
				// 获取 Bean 类中所有的字段（不包括父类中的方法）
				Field[] beanFields = beanClass.getDeclaredFields();
				if (ArrayUtil.isNotEmpty(beanFields)) {
					// 遍历所有的 Bean 字段
					for (Field beanField : beanFields) {
						// 判断当前 Bean 字段是否带有 Autowired 注解
						if (beanField.isAnnotationPresent(Autowired.class)) {

							// 获取 Bean 字段对应的接口
							Class<?> interfaceClass = beanField.getType();

							if(interfaceClass.isInterface()){

								// 获取 Bean 字段对应的实现类
								Class<?> implementClass = findImplementClass(interfaceClass);
								// 若存在实现类，则执行以下代码
								if (implementClass != null) {
									// 从 Bean Map 中获取该实现类对应的实现类实例
									Object implementInstance = beanMap.get(implementClass);
									// 设置该 Bean 字段的值
									if (implementInstance != null) {
										beanField.setAccessible(true); // 将字段设置为 public
										beanField.set(beanInstance, implementInstance);
										// 设置字段初始值
									} else {
										throw new InitializationError("依赖注入失败！类名："
												+ beanClass.getSimpleName()
												+ "，字段名："
												+ interfaceClass.getSimpleName());
									}

								}

							}else{
								Object objInstance = BeanContainerComponent.getBean(interfaceClass);
								if(objInstance != null){
									beanField.setAccessible(true);
									beanField.set(beanInstance, objInstance);
								}
							}

						}

					}
				}
			}
		} catch (Exception e) {
			throw new InitializationError("初始化 IocAbility 出错！", e);
		}

	}
}
